/*
 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.awt.image;

/**
 * This class represents image data which is stored in a pixel interleaved
 * fashion and for
 * which each sample of a pixel occupies one data element of the DataBuffer.
 * It subclasses ComponentSampleModel but provides a more efficient
 * implementation for accessing pixel interleaved image data than is provided
 * by ComponentSampleModel.  This class
 * stores sample data for all bands in a single bank of the
 * DataBuffer. Accessor methods are provided so that image data can be
 * manipulated directly. Pixel stride is the number of
 * data array elements between two samples for the same band on the same
 * scanline. Scanline stride is the number of data array elements between
 * a given sample and the corresponding sample in the same column of the next
 * scanline.  Band offsets denote the number
 * of data array elements from the first data array element of the bank
 * of the DataBuffer holding each band to the first sample of the band.
 * The bands are numbered from 0 to N-1.
 * Bank indices denote the correspondence between a bank of the data buffer
 * and a band of image data.
 * This class supports
 * {@link DataBuffer#TYPE_BYTE TYPE_BYTE},
 * {@link DataBuffer#TYPE_USHORT TYPE_USHORT},
 * {@link DataBuffer#TYPE_SHORT TYPE_SHORT},
 * {@link DataBuffer#TYPE_INT TYPE_INT},
 * {@link DataBuffer#TYPE_FLOAT TYPE_FLOAT} and
 * {@link DataBuffer#TYPE_DOUBLE TYPE_DOUBLE} datatypes.
 */

public class PixelInterleavedSampleModel extends ComponentSampleModel {

  /**
   * Constructs a PixelInterleavedSampleModel with the specified parameters.
   * The number of bands will be given by the length of the bandOffsets
   * array.
   *
   * @param dataType The data type for storing samples.
   * @param w The width (in pixels) of the region of image data described.
   * @param h The height (in pixels) of the region of image data described.
   * @param pixelStride The pixel stride of the image data.
   * @param scanlineStride The line stride of the image data.
   * @param bandOffsets The offsets of all bands.
   * @throws IllegalArgumentException if <code>w</code> or <code>h</code> is not greater than 0
   * @throws IllegalArgumentException if any offset between bands is greater than the scanline
   * stride
   * @throws IllegalArgumentException if the product of <code>pixelStride</code> and <code>w</code>
   * is greater than <code>scanlineStride</code>
   * @throws IllegalArgumentException if <code>pixelStride</code> is less than any offset between
   * bands
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported data
   * types
   */
  public PixelInterleavedSampleModel(int dataType,
      int w, int h,
      int pixelStride,
      int scanlineStride,
      int bandOffsets[]) {
    super(dataType, w, h, pixelStride, scanlineStride, bandOffsets);
    int minBandOff = this.bandOffsets[0];
    int maxBandOff = this.bandOffsets[0];
    for (int i = 1; i < this.bandOffsets.length; i++) {
      minBandOff = Math.min(minBandOff, this.bandOffsets[i]);
      maxBandOff = Math.max(maxBandOff, this.bandOffsets[i]);
    }
    maxBandOff -= minBandOff;
    if (maxBandOff > scanlineStride) {
      throw new IllegalArgumentException("Offsets between bands must be" +
          " less than the scanline " +
          " stride");
    }
    if (pixelStride * w > scanlineStride) {
      throw new IllegalArgumentException("Pixel stride times width " +
          "must be less than or " +
          "equal to the scanline " +
          "stride");
    }
    if (pixelStride < maxBandOff) {
      throw new IllegalArgumentException("Pixel stride must be greater" +
          " than or equal to the offsets" +
          " between bands");
    }
  }

  /**
   * Creates a new PixelInterleavedSampleModel with the specified
   * width and height.  The new PixelInterleavedSampleModel will have the
   * same number of bands, storage data type, and pixel stride
   * as this PixelInterleavedSampleModel.  The band offsets may be
   * compressed such that the minimum of all of the band offsets is zero.
   *
   * @param w the width of the resulting <code>SampleModel</code>
   * @param h the height of the resulting <code>SampleModel</code>
   * @return a new <code>SampleModel</code> with the specified width and height.
   * @throws IllegalArgumentException if <code>w</code> or <code>h</code> is not greater than 0
   */
  public SampleModel createCompatibleSampleModel(int w, int h) {
    int minBandoff = bandOffsets[0];
    int numBands = bandOffsets.length;
    for (int i = 1; i < numBands; i++) {
      if (bandOffsets[i] < minBandoff) {
        minBandoff = bandOffsets[i];
      }
    }
    int[] bandOff;
    if (minBandoff > 0) {
      bandOff = new int[numBands];
      for (int i = 0; i < numBands; i++) {
        bandOff[i] = bandOffsets[i] - minBandoff;
      }
    } else {
      bandOff = bandOffsets;
    }
    return new PixelInterleavedSampleModel(dataType, w, h, pixelStride,
        pixelStride * w, bandOff);
  }

  /**
   * Creates a new PixelInterleavedSampleModel with a subset of the
   * bands of this PixelInterleavedSampleModel.  The new
   * PixelInterleavedSampleModel can be used with any DataBuffer that the
   * existing PixelInterleavedSampleModel can be used with.  The new
   * PixelInterleavedSampleModel/DataBuffer combination will represent
   * an image with a subset of the bands of the original
   * PixelInterleavedSampleModel/DataBuffer combination.
   */
  public SampleModel createSubsetSampleModel(int bands[]) {
    int newBandOffsets[] = new int[bands.length];
    for (int i = 0; i < bands.length; i++) {
      newBandOffsets[i] = bandOffsets[bands[i]];
    }
    return new PixelInterleavedSampleModel(this.dataType, width, height,
        this.pixelStride,
        scanlineStride, newBandOffsets);
  }

  // Differentiate hash code from other ComponentSampleModel subclasses
  public int hashCode() {
    return super.hashCode() ^ 0x1;
  }
}
